packages/job-worker/src/playout/model/implementation/PlayoutModelImpl.ts (1)

783-784: Redundant ID comparison (never fails after map lookup).

The map lookup already keys by _id, so the ID comparison is effectively a no-op and the comment is now misleading. Either drop the check or switch back to a reference check if identity is still required.

♻️ Suggested cleanup

-			// Make sure we were given the exact same object
-			if (storedPartInstance.partInstance._id !== partInstance.partInstance._id)
-				throw new Error(`PartInstance being set as next is not current`)

packages/job-worker/src/playout/lookahead/index.ts (1)

39-42: Guard exported findLargestLookaheadDistance for empty input.

Now that this helper is exported, an empty array could yield -Infinity. Consider a safe default.

🛡️ Safer default

 export function findLargestLookaheadDistance(mappings: Array<[string, MappingExt]>): number {
+	if (mappings.length === 0) return LOOKAHEAD_DEFAULT_SEARCH_DISTANCE
 	const values = mappings.map(([_id, m]) => parseSearchDistance(m.lookaheadMaxSearchDistance))
 	return _.max(values)
 }

packages/job-worker/src/playout/setNext.ts (1)

595-625: Type discrimination logic is inverted from typical convention.

The check !('part' in nextPartOrInstance) discriminates DBPart (which lacks a nested part property) from DBPartInstance (which has one). While functionally correct, this inverted check may confuse future maintainers. Consider adding a clarifying comment or using a type guard function for clarity.

Additionally, the await inside the PlayoutPartInstanceModelImpl constructor call (line 616-618) could benefit from extracting the fetch to a separate statement for better readability and error traceability.

♻️ Suggested refactor for clarity

 	if (!('part' in nextPartOrInstance)) {
+		// nextPartOrInstance is a DBPart (no nested 'part' property)
 		consumesQueuedSegmentId = doesPartConsumeQueuedSegmentId(playoutModel, nextPartOrInstance)

 		await setNextPart(
 			context,
 			playoutModel,
 			{
 				part: nextPartOrInstance,
 				consumesQueuedSegmentId,
 			},
 			setManually,
 			nextTimeOffset
 		)
 	} else {
+		// nextPartOrInstance is a DBPartInstance (has nested 'part' property)
+		const partInstance = nextPartOrInstance as DBPartInstance
+		const pieceInstances = await context.directCollections.PieceInstances.findFetch({
+			partInstanceId: partInstance._id,
+		})
 		await setNextPart(
 			context,
 			playoutModel,
 			new PlayoutPartInstanceModelImpl(
-				nextPartOrInstance as DBPartInstance,
-				await context.directCollections.PieceInstances.findFetch({
-					partInstanceId: nextPartOrInstance._id,
-				}),
+				partInstance,
+				pieceInstances,
 				false,
 				new QuickLoopService(context, playoutModel)
 			),
 			setManually,
 			nextTimeOffset
 		)
 	}

packages/job-worker/src/playout/setNextJobs.ts (1)

70-80: Consider guarding the timeline update.

updateTimeline is called unconditionally at line 80, even when nextPartOrInstance is undefined (meaning no next part was actually set). While this may be harmless, it could be more efficient to skip the timeline update if no change occurred.

♻️ Optional: guard timeline update

 			if (nextPartOrInstance) {
 				await setNextPartFromPart(
 					context,
 					playoutModel,
 					nextPartOrInstance,
 					data.setManually ?? false,
 					data.nextTimeOffset
 				)
+				await updateTimeline(context, playoutModel)
 			}
-
-			await updateTimeline(context, playoutModel)
 		}

packages/webui/src/client/ui/SegmentTimeline/SegmentContextMenu.tsx (1)

288-308: Complex disabled-state logic could benefit from clearer naming.

The getIsPlayFromHereDisabled method has intricate boolean logic that's difficult to follow. Consider:

1. The variable isSelectedTimeWithinBounds (line 292-296) actually checks if offset is beyond bounds (duration < offset), so the name is misleading.
2. The compound condition at line 298 (!take || !!partInstance?.orphaned) is hard to parse.

♻️ Suggested refactor for readability

 	private getIsPlayFromHereDisabled(take: boolean = false): boolean {
 		const offset = this.getTimePosition() ?? 0
 		const playlist = this.props.playlist
 		const partInstance = this.getPartFromContext()?.instance
-		const isSelectedTimeWithinBounds =
+		const isOffsetBeyondExpectedDuration =
 			(partInstance?.part.expectedDuration ??
 				partInstance?.part.displayDuration ??
 				partInstance?.part.expectedDurationWithTransition ??
 				0) < offset

-		if (playlist && playlist?.activationId && (!take || !!partInstance?.orphaned)) {
+		const isPlaylistActive = playlist?.activationId
+		const isOrphanedInstance = !!partInstance?.orphaned
+		const isCurrentPartInstance = partInstance?._id === playlist?.currentPartInfo?.partInstanceId
+
+		if (isPlaylistActive && (!take || isOrphanedInstance)) {
 			if (!partInstance) return true
-			else {
-				return (
-					(isSelectedTimeWithinBounds && partInstance._id === playlist.currentPartInfo?.partInstanceId) ||
-					(!!partInstance.orphaned && partInstance._id === playlist.currentPartInfo?.partInstanceId)
-				)
-			}
+			return (isOffsetBeyondExpectedDuration && isCurrentPartInstance) || 
+			       (isOrphanedInstance && isCurrentPartInstance)
 		}
 		return false
 	}

packages/job-worker/src/playout/lookahead/__tests__/findForLayer/searchDistance.test.ts (1)

43-57: Test name could be more descriptive.

The test "returns nothing when maxSearchDistance is too small" actually tests the case when partInstancesInfo is empty ({}), not specifically about search distance being too small. The mock setup with multiple return values (lines 44-50) is never used since no calls occur.

Consider renaming to clarify the actual scenario being tested.

♻️ Suggested rename

-	test('returns nothing when maxSearchDistance is too small', () => {
+	test('returns nothing when no partInstances are provided', () => {
 		findLookaheadObjectsForPartMock
-			.mockReturnValue([])
-			.mockReturnValueOnce(['t0', 't1'] as any)
-			.mockReturnValueOnce(['t2', 't3'] as any)
-			.mockReturnValueOnce(['t4', 't5'] as any)
-			.mockReturnValueOnce(['t6', 't7'] as any)
-			.mockReturnValueOnce(['t8', 't9'] as any)
+			.mockReturnValue([])

 		const res = findLookaheadForLayer(context, {}, orderedParts, layer, 1, 1, null)

packages/job-worker/src/playout/lookahead/__tests__/findForLayer/basicBehavior.test.ts (1)

26-33: Consider asserting the result in addition to mock calls.

The test verifies that findLookaheadObjectsForPartMock is called with undefined for the previous part, but doesn't assert the actual return value from findLookaheadForLayer. Adding result assertions would strengthen the test.

♻️ Suggested enhancement

 	test('if the previous part is unset', () => {
 		findLookaheadObjectsForPartMock.mockReturnValue([])
 
-		findLookaheadForLayer(context, { previous: undefined, current, next: nextFuture }, [], layer, 1, 1)
+		const res = findLookaheadForLayer(context, { previous: undefined, current, next: nextFuture }, [], layer, 1, 1)
 
+		expect(res.timed).toHaveLength(0)
+		expect(res.future).toHaveLength(0)
 		expect(findLookaheadObjectsForPartMock).toHaveBeenCalledTimes(2)
 		expectInstancesToMatch(findLookaheadObjectsForPartMock, 1, layer, current, undefined)
 	})

packages/job-worker/src/playout/lookahead/__tests__/findForLayer/orderedParts.test.ts (1)

11-25: Redundant beforeEach block.

There are two beforeEach blocks that both reset the same mock (lines 13-15 and lines 21-23). The outer one is sufficient; the inner one can be removed.

♻️ Suggested cleanup

 beforeEach(() => {
 	findLookaheadObjectsForPartMock.mockReset()
 })
 
 const orderedParts = findForLayerTestConstants.orderedParts
 const layer = findForLayerTestConstants.layer
 
 describe('findLookaheadForLayer - orderedParts', () => {
-	beforeEach(() => {
-		findLookaheadObjectsForPartMock.mockReset()
-	})
-
 	const context = setupDefaultJobEnvironment()

packages/job-worker/src/playout/lookahead/__tests__/findForLayer/constants.ts (1)

5-5: Random layer string may complicate test debugging.

Using getRandomString() for the layer means each test run uses a different value. While this provides isolation, it can make debugging failing tests harder since you can't easily reproduce with the same layer value. Consider using a fixed test layer string instead.

♻️ Suggested change

-const layer: string = getRandomString()
+const layer: string = 'test_layer'

packages/job-worker/src/playout/setNextJobs.ts (1)

49-53: Condition logic could benefit from a clearer comment.

The comment says "We can't reuse the currently playing instance," but the condition also falls back to using the Part ID when there is no nextPartInfo or no currentPartInfo. Those first two sub-conditions aren't explained and aren't obvious — it would help future readers to understand why the absence of next/current info requires falling back to the Part rather than reusing the instance.

packages/webui/src/client/ui/SegmentTimeline/SegmentContextMenu.tsx (1)

74-78: isPartNext and isPartOrphaned guards are redundant with the part && check.

Both isPartNext and isPartOrphaned are undefined only when part is falsy (lines 74–78). So isPartNext !== undefined && isPartOrphaned !== undefined at lines 132–133 adds no filtering beyond part && at line 131. If these variables are intended to carry semantic meaning for rendering decisions (beyond null-guarding), they aren't used that way — consider removing the redundant checks or using the boolean values directly.

Also applies to: 131-135

packages/job-worker/src/playout/setNext.ts (1)

576-578: JSDoc @param description is stale.

The description still says "The Part to set as next" but the parameter now also accepts a DBPartInstance.

Suggested fix

- * `@param` nextPartOrInstance The Part to set as next
+ * `@param` nextPartOrInstance The Part or PartInstance to set as next

packages/job-worker/src/playout/lookahead/__tests__/lookaheadOffset/constants.ts (1)

43-43: Typo in function name: generateFakeObectsString → generateFakeObjectsString.

The function name is missing a "j" — Obects instead of Objects. Since this is exported and referenced from test files, a rename now avoids confusion later.

packages/job-worker/src/playout/lookahead/__tests__/findForLayer/timing.test.ts (1)

11-13: mockReset() clears the default implementation set on line 9.

mockReset() removes the mockImplementation(() => []) established earlier. This works here because each test supplies its own mockReturnValueOnce values, but it means any test that doesn't explicitly set a return will get undefined rather than []. Consider using mockClear() if you want the default to persist, or document that each test must set its own return values.

packages/job-worker/src/playout/lookahead/__tests__/lookaheadOffset/lookaheadOffset.test.ts (1)

27-32: jest.resetAllMocks() clears module-level mock implementations.

After resetAllMocks(), the findLargestLookaheadDistanceMock (line 20) and getOrderedPartsAfterPlayheadMock (line 21) lose their default implementations. Tests that don't re-mock findLargestLookaheadDistance before calling getLookeaheadObjects will get undefined from it, causing getOrderedPartsAfterPlayhead to be called with undefined as the partCount argument. This works here because getOrderedPartsAfterPlayhead is itself mocked, but it could hide bugs if the interaction ever matters. Consider jest.clearAllMocks() or re-establishing defaults after reset.

packages/job-worker/src/playout/lookahead/__tests__/findForLayer/constants.ts (1)

7-29: Missing calculatedTimings and nowInPart on some test fixtures.

The PartInstanceAndPieceInstances interface requires calculatedTimings and nowInPart, but none of the fixtures provide calculatedTimings, and nextTimed/nextFuture omit nowInPart. The as any cast hides this. Currently safe because callers use optional chaining (calculatedTimings?.inTransitionStart), but if any consuming test or production code ever accesses these without ?., it will throw at runtime.

Consider adding at least stub values (e.g., calculatedTimings: {}, nowInPart: 0) to reduce brittleness.

packages/job-worker/src/playout/lookahead/findForLayer.ts (1)

108-108: Missing blank line before function declaration.

Minor nit: add a blank line before function generatePartInstanceLookaheads for readability, consistent with the rest of the file's spacing conventions.